package com.lekang.controller;

import com.lekang.common.core.domain.R; // 假设存在统一响应类
import com.lekang.domain.Elderly; // 导入老人实体类
import com.lekang.domain.Floor;
import com.lekang.domain.Room;
import com.lekang.domain.Bed; // 导入床位实体类
import com.lekang.dto.BedDTO;
import com.lekang.service.IBedService;
import com.lekang.service.ICaregiverBedService;
import com.lekang.service.IFloorService;
import com.lekang.service.IRoomService;
import com.lekang.service.IElderlyService; // 假设存在老人Service
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 床位管理控制器
 */
@RestController
@RequestMapping("/api/bed-management")
public class BedManagementController {

    @Autowired
    private IFloorService floorService;

    @Autowired
    private IRoomService roomService;

    @Autowired
    private IBedService bedService;

    @Autowired
    private ICaregiverBedService caregiverBedService;

    @Autowired
    private IElderlyService elderlyService; // 注入老人Service（假设存在）


    // 1. 新增楼层
    @PostMapping("/floor")
    public R<String> addFloor(@RequestBody Floor floor) {
        floorService.insertFloor(floor);
        return R.ok("新增楼层成功");
    }


    /**
     * 编辑楼层
     * 前端通过PUT请求提交更新后的楼层信息（包含id、新名称、新排序等）
     */
    @PutMapping("/floor")
    public R<String> updateFloor(@RequestBody Floor floor) {
        // 校验楼层ID是否存在
        if (floor.getId() == null) {
            return R.fail("楼层ID不能为空");
        }
        // 调用Service更新楼层
        floorService.updateFloor(floor);
        return R.ok("编辑楼层成功");
    }

    /**
     * 删除楼层
     * 前端通过DELETE请求传入楼层ID
     */
    @DeleteMapping("/floor/{id}")
    public R<String> deleteFloor(@PathVariable Long id) {
        // 调用Service删除楼层
        int rows = floorService.deleteFloorById(id);
        if (rows <= 0) {
            return R.fail("删除失败，楼层不存在或已被删除");
        }
        return R.ok("删除楼层成功");
    }




    // 2. 新增房间
    @PostMapping("/room")
    public R<String> addRoom(@RequestBody Room room) {
        roomService.insertRoom(room);
        return R.ok("新增房间成功");
    }

    // 【新增】编辑房间接口（PUT请求）
    @PutMapping("/room")
    public R<String> updateRoom(@RequestBody Room room) {
        if (room.getId() == null) {
            return R.fail("房间ID不能为空");
        }
        roomService.updateRoom(room);
        return R.ok("编辑房间成功");
    }

    // 【新增】删除房间接口（DELETE请求）
    @DeleteMapping("/room/{id}")
    public R<String> deleteRoom(@PathVariable Long id) {
        // 校验：房间下有床位则禁止删除
        Room room = roomService.selectRoomWithBeds(id);
        if (room != null && room.getBeds() != null && room.getBeds().size() > 0) {
            return R.fail("该房间下有床位，无法删除");
        }
        int rows = roomService.deleteRoomById(id);
        if (rows <= 0) {
            return R.fail("删除失败，房间不存在或已被删除");
        }
        return R.ok("删除房间成功");
    }
    /**
     * 新增：查看房间详情（含床位列表）
     * @param id 房间主键
     * @return 房间详情（含床位）
     */
    @GetMapping("/room/{id}")
    public R<Room> getRoomDetail(@PathVariable Long id) {
        Room room = roomService.selectRoomWithBeds(id);
        if (room == null) {
            return R.fail("房间不存在或已被删除");
        }
        return R.ok(room);
    }


    // 3. 新增床位（BedDTO转Bed实体，适配Service层方法）
    @PostMapping("/bed")
    public R<String> addBed(@RequestBody BedDTO bedDTO) {
        // 将DTO转换为实体类（BedService的insertBed接收Bed类型）
        Bed bed = new Bed();
        bed.setBedNo(bedDTO.getBedNo()); // 床位号
        bed.setRoomId(bedDTO.getRoomId()); // 关联房间ID
        // 其他必要属性（如状态默认0，逻辑删除默认0，Service层已处理）
        bedService.insertBed(bed);
        return R.ok("新增床位成功");
    }

    // 4. 绑定护理员到床位（适配ICaregiverBedService的批量绑定方法）
    @PostMapping("/bind-caregiver")
    public R<String> bindCaregiver(
            @RequestParam Long bedId,
            @RequestBody List<Long> caregiverIds // 支持批量绑定，用RequestBody接收列表
    ) {
        // 调用护理员绑定Service（原Service方法是bindCaregiversToBed）
        caregiverBedService.bindCaregiversToBed(bedId, caregiverIds);
        return R.ok("护理员绑定成功");
    }

    // 5. 老人入住（保存老人信息+更新床位状态，添加事务确保原子性）
    @PostMapping("/check-in")
    @Transactional // 确保老人保存和床位状态更新同时成功/失败
    public R<String> checkIn(
            @RequestParam Long bedId,
            @RequestBody Elderly elderly
    ) {
        // 1. 关联床位ID到老人信息
        elderly.setBedId(bedId);
        // 2. 保存老人信息（调用已有insertElderly方法）
        int rows = elderlyService.insertElderly(elderly);
        if (rows <= 0) {
            throw new RuntimeException("老人信息保存失败");
        }
        // 3. 更新床位状态为“已入住”（status=1）
        bedService.checkIn(bedId);
        return R.ok("老人入住成功");
    }

    // 6. 老人请假
    @PostMapping("/ask-leave")
    public R<String> askForLeave(@RequestParam Long bedId) {
        bedService.askForLeave(bedId);
        return R.ok("请假成功");
    }

    // 7. 老人销假
    @PostMapping("/cancel-leave")
    public R<String> cancelLeave(@RequestParam Long bedId) {
        bedService.cancelLeave(bedId);
        return R.ok("销假成功");
    }

    // 8. 查询所有楼层及关联信息（适配IFloorService的方法名）
    @GetMapping("/floors")
    public R<List<Floor>> getAllFloors() {
        // 调用Service层查询楼层及关联信息的方法（原方法名是selectFloorWithRelations）
        List<Floor> floors = floorService.selectFloorWithRelations();
        return R.ok(floors);
    }


    /**
     * 根据楼层ID查询房间列表
     */
    @GetMapping("/rooms")
    public R<List<Room>> getRoomsByFloor(@RequestParam Long floorId) {
        List<Room> rooms = roomService.selectRoomsWithBedsByFloorId(floorId);
        return R.ok(rooms);
    }



}